<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <title>Document</title>
  <style>
    
  </style>
</head>
<body>
  
</body>
<script>

  // - 有一个全是数值的数组，封装函数，计算总和
  function sum(myarr){
    var s = 0;
    // 遍历数组
    for(var i=0;i<myarr.length;i++){
      // 将所有数据，累加
      s += myarr[i];
    }
    // 返回结果
    return s;
  }
  // var arr = [3,4,5,3,2,1,6];
  // console.log( sum(arr) );




  // - 有一个全是数值的数组，封装函数，计算平均值
  function avg(myarr){
    var s = 0;
    for(var i=0;i<myarr.length;i++){
      s += myarr[i];
    }
    return s / myarr.length;
  }
  // var arr = [3,4,5,3,2,1,6];
  // console.log( avg(arr) );




  // - 封装函数：从100~999中取出所有的水仙花数，并返回到函数外部
  function flower(){
    // 准备数组，用于存放数据
    var arr = [];
    // 计算水仙花数
    for(var i=100;i<1000;i++){
      var a = parseInt(i/100)
      var b = parseInt(i/10)%10;
      var c = i % 10;
      if(i === a**3 + b**3 + c**3){
        // 每遇到一个水仙花数，存入数组最后一位
        arr[arr.length] = i;
      }
    }
    // 所有的数字判断完毕，返回最终结果
    return arr;
  }
  // console.log( flower() );




  // - 封装函数：判断一个数组是不是回文数组（对称）
  //   - [1,2,3,2,1]
  //   - [1,2,3,3,2,1]

  // 长度为6
  
  // 0 ~ 5
  // 1 ~ 4
  // 2 ~ 3

  // 0 ~ length-1-0
  // 1 ~ length-1-1
  // 2 ~ length-1-2

  // 长度 / 2 === 3

  // i的范围：0~3(不含)

  // 要比较的数组的索引
  // i ~ arr.length-1-i

  function symmetry(myarr){
    // 取中间值
    var x = parseInt(myarr.length / 2);
    // 从开头遍历到中间值（获取数组一半数据的索引）
    for(var i=0;i<x;i++){
      // 对称位置比较：i ~ arr.length-1-i
      if(myarr[i] !== myarr[myarr.length-1-i]){
        // 只要有一次不相等，就是false
        return false;
      }
    }
    // 没有比较不相等，表示全部相等，才为true
    return true;
  }

  // console.log( symmetry( [1,2,3,2,1] ) );
  // console.log( symmetry( [1,2,3,3,2,1] ) );

  // console.log( symmetry( [1,2,3,4,2,1] ) );
  // console.log( symmetry( [1,2,3,3,2,2] ) );





  // - 封装函数：将一个杂乱的数组(数据至少3个以上)，从大到小排序
  // 举例：十层楼，电梯，每层楼只能停一次，每层楼电梯口都有一颗大小不一的钻石，不能同时持有两颗，如何才能拿到最大的那一颗
  // 选择排序：比较规则：每次拿(第)一个数据，和之后所有数据依次比较，只要发现大的，就取出来，继续和后面的数据再依次比较，直到全部比较完成，取出最大的

  function sort(arr){
    // 比较次数
    // 0-1, 0-2, 0-3, 0-4       i - i+1 ~ length-1
    // 1-2, 1-3, 1-4            i - i+1 ~ length-1
    // 2-3, 2-4                 i - i+1 ~ length-1
    // 3-4                      i - i+1 ~ length-1
    // 行：<length-1
    // 遍历数组，为了每次拿一个数据，用于后之后的数据比较
    for(var i=0; i<arr.length-1; i++){
      // 提前拿一个数据
      var x = arr[i];
      // 并拿这个数据的索引
      var xIndex = i;
      // 再次遍历数组（除了上边已经拿过的数据），准备和之后的数据作比较
      for(var j=i+1; j<arr.length; j++){
        // 将提前拿出来的数据，和之后的数据比较
        if(x < arr[j]){
          // 发现比提前拿出来的数据大的，保存这个大的
          x = arr[j];
          // 同时记录索引
          xIndex = j;
        }
      }
      // 到此表示，一轮比较结束，此时提前拿出来的数据，绝对是本轮比较最大的数据
      // 将数组的初始位置的数据 放在 本轮取出的最大的数据的位置
      arr[xIndex] = arr[i];
      // 将最大的数据，放在初始位置
      arr[i] = x;
      // 初始位置：第一轮0，第二轮1，第三轮2，.....
    }
  }
  var arr = [ 3, 4, 5, 1, 2 ];
  console.log(arr);
  sort(arr);
  console.log(arr);

</script>
</html>